export default {
    data() {
        return {
            //飞机的数据，用于渲染数据
            ganttData: [],

            //默认的高度
            defaultTop: 10,


            //右键菜单所需参数
            rightMenu: {
                //控制显示
                isShow: false,
                //控制位置
                left: 0,
                top: 0,
            }
        }
    },
    computed: {
        //通过选择的时间区间，得到这区间之间的数组
        choiceTimeArr() {
            let timeArr = []
            //时间戳毫秒为单位
            //尾时间-首时间 算出头尾的时间戳差  再换算成天单位                                   毫秒->分->时->天
            let diffDays = (new Date(this.choiceTime[1]).getTime()
                - new Date(this.choiceTime[0]).getTime()) / 1000 / 60 / 60 / 24

            //一天的时间戳
            let oneDayMs = 24 * 60 * 60 * 1000;
            //差了多少天就便利多少天 首时间+当前便利的天数的毫秒数
            for (let i = 0; i < diffDays + 1; i++) {
                //时间戳来一个相加，得到的就是时间数组
                timeArr.push(new Date(new Date(this.choiceTime[0]).getTime() + i * oneDayMs))
            }
            return timeArr
        }
    },
    methods: {
        /**
         * 处理单条的航班的折叠
         * 这样在处理一个拖拽后的航班条的时候，就可以重新计算偏移了
         * @param yData y轴数据对象，其中包括当前对象下的航班条
         */
        handleSingleFold(yData, startTimeCol, endTimeCol) {

            let timeBlockList = yData.timeBlock
            // 排序
            timeBlockList.sort(this.compare(startTimeCol))
            // 数据重置
            for (let i = 0; i < timeBlockList.length; i++) {
                timeBlockList[i].tier = 1
            }

            for (let i = 0; i < timeBlockList.length; i++) {
                const timeItem = timeBlockList[i]
                const originStart = new Date(timeItem[startTimeCol]).getTime()

                if (i !== 0) {
                    // 这一行当前拥有的所有层级 去重
                    const tierArr = Array.from(new Set(timeBlockList.filter(e => e.tier).map(e => e.tier))).sort((a, b) => a - b)

                    //比对层级中是否有重叠，没有重叠则tier+1
                    for (let j = 0; j < tierArr.length; j++) {

                        const tier = tierArr[j]
                        const tierTimeData = timeBlockList
                            .filter((e) => {
                                return e.tier === tier && e.id !== timeItem.id && timeBlockList.findIndex(v => v.id === e.id) < i
                            })
                        let realTier = null

                        // 需要比对的时间  只需要取到当前层级最后一个即可
                        const diffTimeItem = tierTimeData[tierTimeData.length - 1]
                        const diffTimeItemStart = new Date(diffTimeItem[startTimeCol]).getTime()
                        const diffTimeItemEnd = new Date(diffTimeItem[endTimeCol]).getTime()

                        if (originStart >= diffTimeItemStart && originStart <= diffTimeItemEnd) {
                            // 重叠
                            // 层级+1
                            timeItem.tier = tier + 1
                        }
                        else {
                            timeItem.tier = tier

                        }
                        realTier = timeItem.tier

                        if (realTier === tier) {
                            break;
                        }
                    }
                }


                // 计算top + 最初顶上的高度
                let top = 40 * (timeItem.tier - 1) + this.defaultTop * (timeItem.tier - 1) + this.defaultTop
                timeItem.top = top
            }

            //重新计算最高层级
            let tierMap = timeBlockList.map(e => {
                return e.tier ? e.tier : 1
            })

            let maxTier = tierMap.length > 0 ? Math.max(...tierMap) : 1

            yData.height = (maxTier) * 40 + this.defaultTop * (maxTier + 1)

        },

        //生成uuid
        generateUUID() {
            let d = new Date().getTime();
            if (window.performance && typeof window.performance.now === "function") {
                d += performance.now(); //use high-precision timer if available
            }
            let uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
                let r = (d + Math.random() * 16) % 16 | 0;
                d = Math.floor(d / 16);
                return (c == 'x' ? r : (r & 0x3 | 0x8)).toString(16);
            });
            return uuid;
        },
        //排序函数 升序
        compare(property) {
            return function (a, b) {
                // ab 皆为时间类型 需要转换
                let value1 = new Date(a[property]).getTime();
                let value2 = new Date(b[property]).getTime();
                return value1 - value2;
            }
        },
        //根据层级做排序 降序
        compareByTier(dir) {
            return function (a, b) {
                // ab 皆为时间类型 需要转换
                let value1 = a['tier'] || 0;
                let value2 = b['tier'] || 0;

                //升序
                if (dir == 'ASC') {
                    return value1 - value2;
                }
                //降序
                else {
                    return value2 - value1;
                }
            }
        }
    }
}